﻿/*******************************************************    
 * 创建日期：2009年5月5日                              * 
 * 功能名称：SQL数据库访问类                           *
 * 创 建 人：冯 鑫                                     *
 *******************************************************/
/*******************************************************
 * 重载函数:static int DoSqlStr(string str)            *
 * 创建时间: 2009年5月7日                              *
 * 函数功能: 执行单一SQL语句                           *
 * 参数说明: 要执行的SQL语句                           *
 * 返回值:返回受影响的行数                             *
 * 函数说明:此方法是一个静态方法                       *
 * 创建人  : 吴律                                      *                                                   
 * *****************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace DAL
{
    public class C_DBAccess
    {
        public static string connstr;
        private static SqlConnection con;    //声明连接对象

        private static SqlCommand cmd;              //声明命令对象

        private static SqlDataAdapter sda = null;   //声明适配器对象

       

        /// <summary>
        /// 执行不带参数的非查询存储过程
        /// </summary>
        /// <param name="s_procname">存储过程名</param>
        /// <returns>返回影响行数</returns>
        public static int ExeNonQueryProc(string s_procname)
        {   
            con =  new SqlConnection(connstr);
            int i_Return = 0;                                      //用于保存返回值
            using (cmd = new SqlCommand(s_procname, con))
            {
                if (con.State == ConnectionState.Closed)          //如果当前连接处于关闭，则开启连接
                {
                    con.Open();
                }
                try
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    i_Return = cmd.ExecuteNonQuery();            //返回值为执行存储过程影响的行数
                }
                catch (Exception e)                               //捕捉错误
                {
                }
                finally
                {
                    if (con.State == ConnectionState.Open)        //如果当前连接状态处于开启，则关闭连接
                    {
                        con.Close();
                    }
                }
            }
            return i_Return;
        }

        public static string ExeSqlScalar(string sqlstr)
        {
            con = new SqlConnection(connstr);
            string result="";               
            using (cmd = new SqlCommand(sqlstr, con))
            {
                if (con.State == ConnectionState.Closed)          //如果当前连接处于关闭，则开启连接
                {
                    con.Open();
                }
                try
                {
                    cmd.CommandType = CommandType.Text;
                    result = Convert.ToString(cmd.ExecuteScalar()) ;           
                }
                catch (Exception e)                               //捕捉错误
                {
                }
                finally
                {
                    if (con.State == ConnectionState.Open)        //如果当前连接状态处于开启，则关闭连接
                    {
                        con.Close();
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// 执行带参数的非查询存储过程，返回影响行数
        /// </summary>
        /// <param name="s_procname">存储过程名</param>
        /// <param name="parms">参数列表</param>
        /// <returns>影响行数</returns>
        public static int ExeNonQueryProc(string s_procname,ref SqlParameter[] parms)
        {
            con = new SqlConnection(connstr);
            int i_Return = 0;                                      //用于保存返回值 
            using (cmd = new SqlCommand(s_procname, con))
            {
                if (con.State == ConnectionState.Closed)               //如果当前连接处于关闭状态，则打开连接
                {
                    con.Open();
                }
                try
                {                   
                    cmd.CommandType = CommandType.StoredProcedure;
                    foreach (SqlParameter parm in parms)               //遍历参数列表，将参数添加到cmd的参数列表中
                    {
                        cmd.Parameters.Add(parm);
                    }
                    i_Return = cmd.ExecuteNonQuery();                 //返回值为执行存储过程影响的行数
                }
                catch (Exception e)                                   //捕捉错误
                {
                }
                finally
                {
                    if (con.State == ConnectionState.Open)           //如果当前连接状态处于开启，则关闭连接
                    {
                        con.Close();
                    }
                }
            }
            return i_Return;                                       //返回影响行数
        }


        /// <summary>
        /// 执行不带参数的存储过程，填充结果集，判断是否成功
        /// </summary>
        /// <param name="s_procname">存储过程名</param>
        /// <param name="ds">要填充的数据集</param>
        /// <returns>大于0时成功，否则失败</returns>
        public static int GetTable(string s_procname, ref DataSet ds)
        {
            con = new SqlConnection(connstr);
            int i_Return = 0;                                      //用于保存返回值
            using (cmd = new SqlCommand(s_procname, con))
            {
                try
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    sda = new SqlDataAdapter(cmd);                     //实例化适配器
                    i_Return = sda.Fill(ds);                                     //将结果填充到dataset中
                }
                catch (Exception e)                                    //捕捉错误
                {
                }
            }
            return i_Return;                                          //返回填充或刷新行数

        }

        /// <summary>
        /// 执行带参数的存储过程，填充结果集，判断是否成功
        /// </summary>
        /// <param name="s_procname">存储过程名</param>
        /// <param name="parms">参数列表</param>
        /// <param name="ds">要填充的数据集</param>
        /// <returns>大于0时成功，否则失败</returns>
        public static int GetTable(string s_procname, SqlParameter[] parms, ref DataSet ds)
        {
            con = new SqlConnection(connstr);
            int i_Return = 0;                                           //用于保存返回值
            using (cmd = new SqlCommand(s_procname, con))
            {
                try
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    foreach (SqlParameter parm in parms)               //遍历参数列表，将参数添加到cmd的参数列表中
                    {
                        cmd.Parameters.Add(parm);
                    }
                    sda = new SqlDataAdapter(cmd);                     //实例化适配器对象
                    i_Return = sda.Fill(ds);                           //将结果填充到dataset中
                }
                catch (Exception e)                                    //捕捉错误
                {
                }
            }
            return i_Return;                                          //返回填充或刷新行数
        }

        /// <summary>
        /// 执行不带参数的返回单值存储过程
        /// </summary>
        /// <param name="procname">存储过程名</param>
        /// <returns>执行结果</returns>
        public static object ExeScalarProc(string s_procname)
        {
            con = new SqlConnection(connstr);
            object o_ob = null;                                   //用于保存返回值                       
            using (cmd = new SqlCommand(s_procname, con))
            {

                try
                {
                    if (con.State == ConnectionState.Closed)          //如果连接处于关闭，则打开连接
                    {
                        con.Open();
                    }
                    cmd.CommandType = CommandType.StoredProcedure;
                    o_ob = cmd.ExecuteScalar();                       //查询结果
                }
                catch (Exception e)                                   //捕捉错误
                {
                }
                finally
                {
                    if (con.State == ConnectionState.Open)             //如果连接处于开启，则关闭连接
                    {
                        con.Close();
                    }
                }
            }
            return o_ob;                                              //返回结果
        }

        /// <summary>
        /// 执行带参数的返回单值存储过程
        /// </summary>
        /// <param name="procname">存储过程名</param>
        /// <param name="parms">参数列表</param>
        /// <returns>执行结果</returns>
        public static object ExeScalarProc(string s_procname, SqlParameter[] parms)
        {
            con = new SqlConnection(connstr);
            object o_ob = null;                                       //用于保存返回值
            using (cmd = new SqlCommand(s_procname, con))
            {

                try
                {
                    if (con.State == ConnectionState.Closed)              //如果当前连接处于关闭，则打开连接
                    {
                        con.Open();
                    }
                    cmd.CommandType = CommandType.StoredProcedure;
                    foreach (SqlParameter parm in parms)                  //遍历参数列表，将参数添加到cmd的参数列表中
                    {
                        cmd.Parameters.Add(parm);
                    }
                    o_ob = cmd.ExecuteScalar();                          //查询结果
                }
                catch (Exception e)                                      //捕捉错误
                {

                }
                finally
                {
                    if (con.State == ConnectionState.Open)               //如果连接处于开启，则关闭连接
                    {
                        con.Close();
                    }
                }
            }
            return o_ob;
        }

        /// <summary>
        /// 执行单一SQL语句，填充结果集
        /// </summary>
        /// <param name="s_sqlstr">sql语句</param>
        /// <param name="ds">用于接收结果集的dataset</param>
        /// <returns>大于0时执行成功，否则失败</returns>
        public static int DoSqlStr(string s_sqlstr, ref DataSet ds)
        {
            con = new SqlConnection(connstr);
            int i_Return = 0;                                           //用于接收返回值
            using (cmd = new SqlCommand(s_sqlstr, con))
            {
                try
                {
                    if (con.State == ConnectionState.Closed)           //如果连接处于关闭，则开启连接
                    {
                        con.Open();
                    }
                    cmd.CommandType = CommandType.Text;
                    sda = new SqlDataAdapter(cmd);                    //实例化适配器对象
                    i_Return = sda.Fill(ds);                          //填充结果集
                }
                catch                                                 //捕捉错误
                {
                }
                finally
                {
                    if (con.State == ConnectionState.Open)           //如果连接处于开启，则关闭连接
                    {
                        con.Close();
                    }
                }
            }
            return i_Return;                                         //返回影响行数
        }

        public static int DoSqlStr(string s_sqlstr)
        {
            con = new SqlConnection(connstr);
            int i_Return = 0;                                           //用于接收返回值
            using (cmd = new SqlCommand(s_sqlstr, con))
            {
                try
                {
                    if (con.State == ConnectionState.Closed)           //如果连接处于关闭，则开启连接
                    {
                        con.Open();
                    }
                    cmd.CommandType = CommandType.Text;
                    i_Return = cmd.ExecuteNonQuery();
                }
                catch(Exception ee)                                                //捕捉错误
                {
                }
                finally
                {
                    if (con.State == ConnectionState.Open)           //如果连接处于开启，则关闭连接
                    {
                        con.Close();
                    }
                }
            }
            return i_Return;     
        }
    }
}
